package vengadores;

import java.io.IOException;
import java.util.Random;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.Sprite;

/**
 * Clase que representa a un enemigo del Heroe, este personaje le bajará vida al heroe y le hará la vida imposible
 * para que su avance no sea tan fácil
 * @author Felipe Donato Arrazola Gómez 1165547
 * @author Arturo Ayala Tello 1164742
 * @author Jorge de Jesús Tinoco Huesca 1165318
 */


public class Enemigo extends Sprite{

    /**
     * variable que aloja si el enemigo está parado
     */
    protected boolean estaParado = false;
    /**
     * variable que aloja si el enemigo está golpeando
     */
    protected boolean estaGolpeando = false;
    /**
     * variable que aloja si el enemigo ha sido golpeado
     */
    protected boolean haSidoGolpeado = false;
    /**
     * variable que aloja si el enemigo está corriendo
     */
    protected boolean estaCorriendo = false;
    /**
     * variable que aloja si el enemigo está muriendo
     */
    protected boolean estaMuriendo = false;
    /**
     * variable que aloja si el enemigo está apareciendo
     */
    protected boolean estaApareciendo = false;
    /**
     * variable que aloja si el enemigo está desapareciendo
     */
    protected boolean estaDesapareciendo = false;
    /**
     * variable que aloja si el enemigo está disparando
     */
    protected boolean estaDisparando = false;
    /**
     * variable que aloja si el obstaculo se está rompiendo
     */
    protected boolean estaRompiendo = false;
    private int disparar[] = {6,6,6};
    private int desaparecer[] = {4,4,3,3,2,2,1,1,0,0};
    private int aparecer[] = {0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4};
    private int corriendo[]={1,1,2,2,3,3,4,4,5,5,6,6};
    private int posicionParado[] = {0};
    private int golpe[] = {7,7,8,8,8,8,8,9,9,9,9};
    private int golpeado[] = {20,20,21,21};
    private int muriendo[] = {20,20,21,21,22,22,23,23,24,24,25,25};
    private int rompiendo[] = {1,1,1,1};

    /**
     * Constante entera con valor de 1 que representa el tipo del enemigo del modo de Plataforma.
     */
    public static final int PLATAFORMA = 1;
    /**
     * Constante entera con valor de 2 que representa el tipo del enemigo del modo de Shooter.
     */
    public static final int SHOOTER = 2;
    /**
     * Constante entera con valor de 3 que representa un obstaculo no móvil.
     */
    public static final int OBSTACULO = 3;
    /**
     * Constante entera con valor de 4 que representa un obstaculo móvil.
     */
    public static final int OBSTACULO_MOVIL = 4;
    /**
     * Constante entera con valor de 5 que representa un Jefe.
     */
    public static final int JEFE = 5;
    /**
     * Constante entera que aloja el último frame de la secuencia de golpe
     */
    public static int ULTGOLPE;
    /**
     * Constante entera que aloja el último frame de la secuencia cuando ha sido golpeado
     */
    public static int ULTGOLPEADO;
    /**
     * Constante entera que aloja el último frame de la secuencia cuando muere
     */
    public static int ULTMUERTO;
    /**
     * Constante entera que aloja el último frame de la secuencia cuando aparece
     */
    public static int ULTAPARECER;
    /**
     * Constante entera que aloja el último frame de la secuencia cuando desaparece
     */
    public static int ULTDESAPARECER;
    /**
     * Constante entera que aloja el último frame de la secuencia cuando dispara
     */
    public static int ULTDISPARO;
    /**
     * Constante entera que aloja el último frame de la secuencia cuando se rompe un obstaculo móvil
     */
    public static int ULTROTO;
    /**
     * Variable que aloja el valor lógico del movimiento
     */
    protected int contadorShooter;
    /**
     * Variable que aloja las veces que el enemigo ha sido golpeado
     */
    protected int vecesGolpeado;
    private int tipo;//tipo del enemigo
    private Random r;//objeto que genera números al azar

    /**
     * Constructor de la clase que genera un enemigo con respecto al tipo que se le envia y al nivel al que pertenece
     * el enemigo
     * @param tipoEnemigo constante entera que representa el tipo del enemigo
     * @param nivel nivel al que pertenece el enemigo
     * @throws IOException si los archivos de las imágenes de los enemigos no existen
     */
    public Enemigo(int tipoEnemigo, int nivel) throws IOException{
        super(Image.createImage("/SpriteVacio.png"));
        tipo = tipoEnemigo;
        vecesGolpeado = 0;
        r = new Random();
        if(tipo == PLATAFORMA){
            super.setImage(Image.createImage("/EnemigoSprite.png"),95,66);
            ULTGOLPE = golpe.length-1;
            ULTGOLPEADO = golpeado.length-1;
            ULTMUERTO = muriendo.length-1;
        }else if(tipo == SHOOTER){
            super.setImage(Image.createImage("/EnemigoShooter" + nivel + ".png"), 50,50);
            ULTAPARECER = aparecer.length-1;
            ULTDESAPARECER = desaparecer.length-1;
            ULTDISPARO = disparar.length-1;
        }else if(tipo == OBSTACULO){
            super.setImage(Image.createImage("/Obstaculo" + nivel + ".png"), 46, 41);
        }else if(tipo == OBSTACULO_MOVIL){
            if(nivel == 2){
                super.setImage(Image.createImage("/ObstaculoMovil2.png"),40,33);
            }else if(nivel == 3){
                super.setImage(Image.createImage("/ObstaculoMovil3.png"), 80, 80);
            }
            ULTROTO = rompiendo.length-1;
        }
    }

    /**
     * Método que se encarga de hacer correr al heroe
     * @param direccion es el valor lógico de la dirección. Si es verdadero, va hacia la derecha, si es falso
     * va hacia la izquierda
     */
    public void correr(boolean direccion){ //true = derecha, false = izquierda
        int x = getX();
        int y = getY();
        estaGolpeando = false;
        estaParado = false;
        if (!estaCorriendo){
            super.setFrameSequence(corriendo);
            estaCorriendo = true;
        }
        if(direccion){
            setTransform(Sprite.TRANS_NONE);
            setPosition(x,y);
            move(1,0);
        }else{
            setTransform(Sprite.TRANS_MIRROR);
            setPosition(x,y);
            move(-1,0);
        }
    }

    /**
     * Método que se encarga de poner al enemigo en su posición de parado
     */

    public void parado() {
        super.setFrameSequence(posicionParado);
        estaCorriendo = false;
        estaGolpeando = false;
        estaParado = true;
    }

    /**
     * Método que se encarga de hacer que el enemigo golpee
     */

    public void golpear(){
        estaCorriendo = false;
        estaParado = false;
        if (!estaGolpeando){
            super.setFrameSequence(golpe);
            estaGolpeando = true;
        }
        if (super.getFrame() == ULTGOLPE){
            estaGolpeando = false;
        }
    }

    /**
     * Método que se encarga de poner la secuencia de que el enemigo ha sido golpeado
     */

    public void golpeado(){
        estaParado = false;
        estaGolpeando = false;
        estaCorriendo = false;
        if(!haSidoGolpeado){
            super.setFrameSequence(golpeado);
            haSidoGolpeado = true;
        }
        if(super.getFrame() == ULTGOLPEADO){
            haSidoGolpeado = false;
        }
    }

    /**
     * Método que regresa el tipo de enemigo
     * @return el tipo de enemigo
     */
    public int getTipo() {
        return tipo;
    }

    /**
     * Método que se encarga de poner la secuencia para que el enemigo muera
     */

    public void morir() {
        estaParado = false;
        estaGolpeando = false;
        estaCorriendo = false;
        vecesGolpeado = 0;
        if(!estaMuriendo){
            super.setFrameSequence(muriendo);
            estaMuriendo = true;
        }
        if(super.getFrame() == ULTMUERTO){
            estaMuriendo = false;
        }
    }

    /**
     * Método que se encarga de aparecer al enemigo en modo de Shooter
     */
    public void aparecerShooter(){
        if(!estaApareciendo){
            super.setFrameSequence(aparecer);
            estaApareciendo = true;
        }
        if(super.getFrame() == ULTAPARECER){
            estaApareciendo = false;
        }
    }

    /**
     * Método que se encarga de desaparecer al enemigo en modo de Shooter
     */

    public void desaparecerShooter(){
        if(!estaDesapareciendo){
            super.setFrameSequence(desaparecer);
            estaDesapareciendo = true;
        }
        if(super.getFrame() == ULTDESAPARECER){
            estaDesapareciendo = false;
            super.setPosition(r.nextInt(200), 20 + r.nextInt(140));
        }
    }

    /**
     * Método que se encarga de hacer que el enemigo de tipo Shooter dispare
     */

    public void disparar(){
        if(!estaDisparando){
            if(this.tipo==Enemigo.SHOOTER)
               super.setFrameSequence(disparar);
            estaDisparando = true;
        }
        if(super.getFrame() == ULTDISPARO){
            estaDisparando = false;
        }

    }

    /**
     * Método que se encarga de romper los obstaculos móviles cuando caen al suelo
     */

    public void romperObstaculo() {
        if(!estaRompiendo){
            super.setFrameSequence(rompiendo);
            estaRompiendo = true;
        }
        if(super.getFrame() == ULTROTO){
            estaRompiendo = false;
        }
    }
}